package com.example.show_auto.utils

import com.example.show_auto.data.Chef
import com.example.show_auto.data.Skill

/**
 * 厨师间技法影响计算器
 * 实现web项目中的Partial和Next技能影响逻辑
 */
object ChefInteractionCalculator {
    
    /**
     * 技法影响类型
     */
    enum class SkillCondition {
        PARTIAL,  // 全场生效
        NEXT,     // 下一位厨师生效
        SELF      // 只对自己生效
    }
    
    /**
     * 技法影响效果
     */
    data class SkillEffect(
        val condition: SkillCondition,
        val skillType: String,  // 技法类型：Stirfry, Boil, Knife, Fry, Bake, Steam
        val value: Int          // 加成数值
    )
    
    /**
     * 计算厨师间的技法影响
     * @param selectedChefs 选中的厨师列表（最多3个）
     * @param skills 技能数据列表
     * @param enabledAuraChefs 设置页面中选中的光环厨师名称集合（可选，为空时使用原逻辑）
     * @return 每个位置厨师受到的额外技法加成
     */
    fun calculateChefInteractions(
        selectedChefs: List<Chef>,
        skills: List<Skill>,
        enabledAuraChefs: Set<String>? = null
    ): List<Map<String, Int>> {
        val chefCount = minOf(selectedChefs.size, 3)
        val interactions = mutableListOf<Map<String, Int>>()
        
        // 初始化每个位置的技法加成
        repeat(3) {
            interactions.add(mutableMapOf(
                "stirfry" to 0,
                "boil" to 0,
                "knife" to 0,
                "fry" to 0,
                "bake" to 0,
                "steam" to 0
            ))
        }
        
        // 遍历每个厨师，计算其技能对其他厨师的影响
        for (chefIndex in 0 until chefCount) {
            val chef = selectedChefs.getOrNull(chefIndex)
            if (chef == null || chef.name.isEmpty()) continue

            // 判断厨师是否能提供技法影响
            val canProvideAura = if (enabledAuraChefs != null) {
                // 使用设置页面的选择：只有在设置中选中的光环厨师才能提供技法影响
                enabledAuraChefs.contains(chef.name)
            } else {
                // 使用原逻辑：已修炼的厨师或者有NEXT技能的厨师都能提供技法影响
                chef.ult || hasNextTypeSkillInCalculator(chef, skills)
            }

            if (!canProvideAura) continue
            
            // 获取厨师的修炼技能效果
            val skillEffects = getChefSkillEffects(chef, skills)
            
            // 应用技能效果
            for (effect in skillEffects) {
                when (effect.condition) {
                    SkillCondition.PARTIAL -> {
                        // 全场生效：影响所有位置（包括自己）
                        for (targetIndex in 0 until 3) {
                            applySkillEffect(interactions[targetIndex] as MutableMap<String, Int>, effect)
                        }
                    }
                    SkillCondition.NEXT -> {
                        // 下一位生效：只影响下一个位置
                        val nextIndex = chefIndex + 1
                        if (nextIndex < 3) {
                            applySkillEffect(interactions[nextIndex] as MutableMap<String, Int>, effect)
                        }
                    }
                    SkillCondition.SELF -> {
                        // 自己生效：只影响自己（这部分由个人技法处理，这里不处理）
                    }
                }
            }
        }
        
        return interactions
    }
    
    /**
     * 检查厨师是否有NEXT类型技能（在ChefInteractionCalculator内部使用）
     */
    private fun hasNextTypeSkillInCalculator(chef: Chef, skills: List<Skill>): Boolean {
        if (!chef.hasUltimateSkill()) return false

        return chef.getAllUltimateSkills().any { sid ->
            val ultimateSkill = skills.find { it.skillId == sid } ?: return@any false
            val effects = parseSkillDescription(ultimateSkill.desc)
            effects.any { it.condition == SkillCondition.NEXT }
        }
    }
    
    /**
     * 获取厨师的修炼技能效果
     * @param chef 厨师数据
     * @param skills 技能数据列表
     * @return 技能效果列表
     */
    private fun getChefSkillEffects(chef: Chef, skills: List<Skill>): List<SkillEffect> {
        if (!chef.hasUltimateSkill()) return emptyList()
        val effects = mutableListOf<SkillEffect>()
        for (skillId in chef.getAllUltimateSkills()) {
            val ultimateSkill = skills.find { it.skillId == skillId } ?: continue
            effects += parseSkillDescription(ultimateSkill.desc)
        }
        return effects
    }
    
    /**
     * 解析技能描述，提取技法影响效果
     * @param skillDesc 技能描述
     * @return 技能效果列表
     */
    fun parseSkillDescription(skillDesc: String): List<SkillEffect> {
        val effects = mutableListOf<SkillEffect>()

        // 解析各种技法加成
        val skillTypes = mapOf(
            "炒" to "stirfry",
            "煮" to "boil",
            "切" to "knife",
            "炸" to "fry",
            "烤" to "bake",
            "蒸" to "steam"
        )

        // 检查全技法加成（优先处理）
        val allSkillPatterns = listOf(
            // 下位上场厨师全技法+X
            "下位上场厨师全技法([+\\-]?\\d+)".toRegex(),
            // 下个厨师全技法+X
            "下个?厨师全技法([+\\-]?\\d+)".toRegex(),
            "下一位厨师全技法([+\\-]?\\d+)".toRegex(),
            // 所有厨师全技法+X
            "所有厨师全技法([+\\-]?\\d+)".toRegex(),
            "全场厨师全技法([+\\-]?\\d+)".toRegex(),
            "场上所有厨师全技法([+\\-]?\\d+)".toRegex(),
            // 简单的全技法+X
            "全技法([+\\-]?\\d+)".toRegex()
        )

        for (pattern in allSkillPatterns) {
            val match = pattern.find(skillDesc)
            if (match != null) {
                val value = match.groupValues[1].toIntOrNull() ?: 0
                val condition = when {
                    skillDesc.contains("下位上场厨师") || skillDesc.contains("下个厨师") || skillDesc.contains("下一位厨师") -> SkillCondition.NEXT
                    skillDesc.contains("所有厨师") || skillDesc.contains("全场厨师") || skillDesc.contains("场上所有厨师") -> SkillCondition.PARTIAL
                    else -> SkillCondition.SELF
                }

                // 全技法影响所有6种技法
                for (skillType in skillTypes.values) {
                    effects.add(SkillEffect(condition, skillType, value))
                }
                break // 找到全技法就不再查找单项技法
            }
        }

        // 如果没有找到全技法，再检查单项技法
        if (effects.isEmpty()) {
            // 先尝试解析复合技法描述（如：场上所有厨师切+30且炒+30）
            parseCompoundSkillEffects(skillDesc, skillTypes, effects)
            
            // 如果没有找到复合技法，再检查单项技法
        if (effects.isEmpty()) {
            for ((chineseType, englishType) in skillTypes) {
                val patterns = listOf(
                    // 下位上场厨师X技法+Y 或 下位上场厨师X+Y
                    "下位上场厨师${chineseType}技法([+\\-]?\\d+)".toRegex(),
                    "下位上场厨师${chineseType}([+\\-]?\\d+)".toRegex(),
                    // 下个厨师X技法+Y
                    "下个?厨师${chineseType}技法([+\\-]?\\d+)".toRegex(),
                    "下一位厨师${chineseType}技法([+\\-]?\\d+)".toRegex(),
                    // 所有厨师X技法+Y 或 场上所有厨师X+Y
                    "所有厨师${chineseType}技法([+\\-]?\\d+)".toRegex(),
                    "全场厨师${chineseType}技法([+\\-]?\\d+)".toRegex(),
                    "场上所有厨师${chineseType}([+\\-]?\\d+)".toRegex(),
                    // 简单的X技法+Y
                    "${chineseType}技法([+\\-]?\\d+)".toRegex()
                )

                for (pattern in patterns) {
                    val match = pattern.find(skillDesc)
                    if (match != null) {
                        val value = match.groupValues[1].toIntOrNull() ?: 0
                        val condition = when {
                            skillDesc.contains("下位上场厨师") || skillDesc.contains("下个厨师") || skillDesc.contains("下一位厨师") -> SkillCondition.NEXT
                            skillDesc.contains("所有厨师") || skillDesc.contains("全场厨师") || skillDesc.contains("场上所有厨师") -> SkillCondition.PARTIAL
                            else -> SkillCondition.SELF
                        }
                        effects.add(SkillEffect(condition, englishType, value))
                        break
                        }
                    }
                }
            }
        }

        return effects
    }
    
    /**
     * 解析复合技法描述（如：场上所有厨师切+30且炒+30）
     * @param skillDesc 技能描述
     * @param skillTypes 技法类型映射
     * @param effects 效果列表（输出）
     */
    private fun parseCompoundSkillEffects(
        skillDesc: String, 
        skillTypes: Map<String, String>, 
        effects: MutableList<SkillEffect>
    ) {
        // 确定技能作用条件
        val condition = when {
            skillDesc.contains("下位上场厨师") || skillDesc.contains("下个厨师") || skillDesc.contains("下一位厨师") -> SkillCondition.NEXT
            skillDesc.contains("所有厨师") || skillDesc.contains("全场厨师") || skillDesc.contains("场上所有厨师") -> SkillCondition.PARTIAL
            else -> SkillCondition.SELF
        }

        // 查找所有技法加成（使用更灵活的正则表达式）
        for ((chineseType, englishType) in skillTypes) {
            // 匹配：切+30、炒+30 等
            val patterns = listOf(
                "${chineseType}([+\\-]?\\d+)".toRegex(),
                "${chineseType}技法([+\\-]?\\d+)".toRegex()
            )
            
            for (pattern in patterns) {
                val match = pattern.find(skillDesc)
                if (match != null) {
                    val value = match.groupValues[1].toIntOrNull() ?: 0
                    effects.add(SkillEffect(condition, englishType, value))
                    break // 找到此技法的加成就跳出pattern循环，继续下一个技法类型
                }
            }
        }
    }
    
    /**
     * 应用技能效果到目标位置
     * @param targetSkills 目标位置的技法加成映射
     * @param effect 技能效果
     */
    private fun applySkillEffect(targetSkills: MutableMap<String, Int>, effect: SkillEffect) {
        val currentValue = targetSkills[effect.skillType] ?: 0
        targetSkills[effect.skillType] = currentValue + effect.value
    }
    
    /**
     * 获取指定位置厨师受到的技法加成描述
     * @param chefIndex 厨师位置索引（0-2）
     * @param interactions 技法影响计算结果
     * @return 技法加成描述文本
     */
    fun getInteractionDescription(chefIndex: Int, interactions: List<Map<String, Int>>): String {
        if (chefIndex >= interactions.size) return ""
        
        val skillBonus = interactions[chefIndex]
        val descriptions = mutableListOf<String>()
        
        val skillNames = mapOf(
            "stirfry" to "炒",
            "boil" to "煮",
            "knife" to "切", 
            "fry" to "炸",
            "bake" to "烤",
            "steam" to "蒸"
        )
        
        for ((skillType, chineseName) in skillNames) {
            val bonus = skillBonus[skillType] ?: 0
            if (bonus != 0) {
                val sign = if (bonus > 0) "+" else ""
                descriptions.add("${chineseName}${sign}${bonus}")
            }
        }
        
        return if (descriptions.isNotEmpty()) {
            "队友加成: ${descriptions.joinToString(" ")}"
        } else {
            ""
        }
    }
    
    /**
     * 检查是否有任何技法加成
     * @param interactions 技法影响计算结果
     * @param chefIndex 厨师位置索引
     * @return 是否有技法加成
     */
    fun hasAnyInteraction(interactions: List<Map<String, Int>>, chefIndex: Int): Boolean {
        if (chefIndex >= interactions.size) return false

        val skillBonus = interactions[chefIndex]
        return skillBonus.values.any { it != 0 }
    }

    /**
     * 调试方法：获取厨师技能解析结果
     * @param chef 厨师数据
     * @param skills 技能数据列表
     * @return 技能解析结果描述
     */
    fun debugChefSkillEffects(chef: Chef, skills: List<Skill>): String {
        if (!chef.ult || !chef.hasUltimateSkill()) return "无修炼技能"
        
        val skillId = chef.getFirstUltimateSkill()
        val ultimateSkill = skills.find { it.skillId == skillId }
            ?: return "技能数据未找到"

        val effects = parseSkillDescription(ultimateSkill.desc)
        if (effects.isEmpty()) return "技能描述: ${ultimateSkill.desc} -> 无解析结果"

        val effectDescriptions = effects.map { effect ->
            "${effect.condition.name}: ${effect.skillType}${if(effect.value >= 0) "+" else ""}${effect.value}"
        }

        return "技能描述: ${ultimateSkill.desc} -> ${effectDescriptions.joinToString(", ")}"
    }
}
